package com.prevpn.service.impl;

import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.prevpn.api.GroupApi;
import com.prevpn.common.CommonResponse;
import com.prevpn.common.CommonUtil;
import com.prevpn.dto.GroupCreatDTO;
import com.prevpn.dto.GroupUpdateDTO;
import com.prevpn.service.GroupService;
import com.prevpn.vo.GroupDetailVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * GroupServiceImpl - 实现组织架构创建业务逻辑
 */
@Slf4j
@Service
public class GroupServiceImpl implements GroupService {

    private final GroupApi groupApi = new GroupApi();


    //新增组织架构
    @Override
    public CommonResponse<Map<String, Object>> createGroup(GroupCreatDTO dto) {
        // 步骤1: 基本参数校验
        if (dto == null || dto.getGroup() == null ||
                StrUtil.isBlank(dto.getGroup().getKey()) ||
                StrUtil.isBlank(dto.getGroup().getData())) {
            CommonResponse<Map<String, Object>> resp = new CommonResponse<>();
            resp.setCode("400");
            resp.setMsg("上级组织架构信息不完整");
            return resp;
        }

        // 步骤2: 递归检查并创建所有不存在的上级组织
        try {
            ensureParentGroupExists(dto.getDirectoryDomain(), dto.getGroup().getData());
        } catch (RuntimeException e) {
            log.error("自动创建上级组织架构失败: {}", e.getMessage(), e);
            CommonResponse<Map<String, Object>> resp = new CommonResponse<>();
            resp.setCode("500");
            resp.setMsg("自动创建上级组织架构失败: " + e.getMessage());
            return resp;
        }

        // 步骤3: 创建最终的目标组织架构
        log.info("所有上级组织均已存在，开始创建目标组织: {}", dto.getName());
        return groupApi.createGroup(
                dto.getDirectoryDomain(),
                dto.getName(),
                dto.getGroup().getKey(),
                dto.getGroup().getData(),
                dto.getDescription(),
                dto.getExternalId()
        );
    }

    /**
     * 递归确保上级组织存在，如果不存在则自动创建
     * @param directoryDomain 用户目录
     * @param fullPath 需要确保存在的组织路径
     */
    private void ensureParentGroupExists(String directoryDomain, String fullPath) {
        // 递归基线：根路径 "/" 默认存在，无需检查或创建
        if (StrUtil.isBlank(fullPath) || "/".equals(fullPath)) {
            return;
        }

        try {
            // 尝试查询该路径，如果成功，说明它已存在，直接返回
            queryGroupByFullPath(directoryDomain, fullPath);
            log.info("组织架构已存在: {}", fullPath);
        } catch (RuntimeException e) {
            // 捕获到异常，大概率是 "组织架构不存在"
            log.warn("组织架构 '{}' 不存在，即将自动创建。", fullPath);

            // 1. 找到它的上一级路径
            int lastSlashIndex = fullPath.lastIndexOf('/');
            String parentPath = (lastSlashIndex > 0) ? fullPath.substring(0, lastSlashIndex) : "/";
            String currentGroupName = fullPath.substring(lastSlashIndex + 1);

            // 2. 递归确保它的上一级路径存在
            ensureParentGroupExists(directoryDomain, parentPath);

            // 3. 创建当前这一级的组织
            log.info("正在创建上级组织: '{}' 于 '{}' 之下", currentGroupName, parentPath);
            CommonResponse<Map<String, Object>> createResponse = groupApi.createGroup(
                    directoryDomain,
                    currentGroupName,
                    "fullPath", // 上级组织的定位方式固定为fullPath
                    parentPath,
                    "Auto-created parent group", // 为自动创建的组织添加一个默认描述
                    null
            );

            // 如果自动创建失败，则向上抛出异常，终止整个流程
            if (!"OK".equalsIgnoreCase(createResponse.getCode())) {
                throw new RuntimeException("自动创建组织 '" + fullPath + "' 失败: " + createResponse.getMsg());
            }
            log.info("成功创建上级组织: {}", fullPath);
        }
    }


    //编辑组织架构
    @Override
    public CommonResponse<Map<String, Object>> updateGroup(GroupUpdateDTO dto) {
        CommonResponse<Map<String, Object>> resp = new CommonResponse<>();

        // 参数校验
        if (dto == null || StrUtil.isBlank(dto.getDirectoryDomain()) || StrUtil.isBlank(dto.getFullPath())) {
            resp.setCode("400");
            resp.setMsg("参数不完整：directoryDomain 和 fullPath 必须提供");
            return resp;
        }

        // 提取上级组织信息（可能为空）
        String groupKey = null;
        String groupData = null;
        if (dto.getGroup() != null) {
            groupKey = dto.getGroup().getKey();
            groupData = dto.getGroup().getData();
        }

        // 调用 aTrust API
        CommonResponse<Map<String, Object>> apiResp = groupApi.updateGroup(
                dto.getDirectoryDomain(),
                dto.getFullPath(),
                dto.getName(),
                dto.getDescription(),
                dto.getExternalId(),
                groupKey,
                groupData
        );

        if (!"OK".equalsIgnoreCase(apiResp.getCode())) {
            resp.setCode(apiResp.getCode());
            resp.setMsg("更新失败：" + apiResp.getMsg());
        } else {
            resp.setCode("OK");
            resp.setMsg("更新成功");
            resp.setData(apiResp.getData());
            resp.setTraceId(apiResp.getTraceId());
        }

        return resp;
    }

    //基于路径查询
    //@Override
    //public GroupDetailVO queryGroupByFullPath(String directoryDomain, String fullPath) {
    //    // 直接调用封装好的 API 方法
    //    CommonResponse<Map<String, Object>> apiResponse = groupApi.queryGroupByFullPath(directoryDomain, fullPath);
    //
    //    // 检查返回结果
    //    if (!"OK".equalsIgnoreCase(apiResponse.getCode())) {
    //        throw new RuntimeException("查询失败：" + apiResponse.getMsg());
    //    }
    //
    //    // 将返回的 Map 转换为 VO 对象
    //    GroupDetailVO vo = JSONUtil.toBean(
    //            JSONUtil.toJsonStr(apiResponse.getData()),
    //            GroupDetailVO.class
    //    );
    //
    //    return vo;
    //}
    @Override
    public CommonResponse<GroupDetailVO> queryGroupByFullPath(String directoryDomain, String fullPath) {
        // 调用底层 API
        CommonResponse<Map<String, Object>> apiResponse = groupApi.queryGroupByFullPath(directoryDomain, fullPath);

        // 创建新的响应包装类
        CommonResponse<GroupDetailVO> result = new CommonResponse<>();
        result.setCode(apiResponse.getCode());
        result.setMsg(apiResponse.getMsg());
        result.setTraceId(apiResponse.getTraceId());

        // 如果接口失败，直接返回错误响应
        if (!"OK".equalsIgnoreCase(apiResponse.getCode())) {
            return result;
        }

        // data 字段转换为 GroupDetailVO
        GroupDetailVO vo = JSONUtil.toBean(
                JSONUtil.toJsonStr(apiResponse.getData()),
                GroupDetailVO.class
        );
        result.setData(vo);
        return result;
    }


    //删除组织架构（支持批量删除）
    @Override
    public CommonResponse<Map<String, Object>> deleteByFullPathList(String directoryDomain, List<String> fullPathList) {
        CommonResponse<Map<String, Object>> result = new CommonResponse<>();

        if (fullPathList == null || fullPathList.isEmpty()) {
            result.setCode("400");
            result.setMsg("删除失败：fullPathList 不能为空");
            result.setData(new HashMap<>());
            return result;
        }

        // 1️⃣ 区分存在与不存在的路径
        List<String> existPaths = new ArrayList<>();
        List<String> notExistPaths = new ArrayList<>();

        for (String path : fullPathList) {
            try {
                CommonResponse<Map<String, Object>> queryResp = groupApi.queryGroupByFullPath(directoryDomain, path);
                if ("OK".equalsIgnoreCase(queryResp.getCode())) {
                    existPaths.add(path);
                } else {
                    notExistPaths.add(path);
                }
            } catch (Exception e) {
                notExistPaths.add(path);
            }
        }

        // 2️⃣ 如果没有任何存在的路径
        if (existPaths.isEmpty()) {
            result.setCode("404");
            result.setMsg("删除失败：所有路径均不存在 → " + notExistPaths);
            result.setData(new HashMap<>());
            return result;
        }

        // 3️⃣ 调用 aTrust 接口删除存在的组织架构
        CommonResponse<Map<String, Object>> apiResponse =
                groupApi.deleteGroupByFullPathList(directoryDomain, existPaths);

        // 4️⃣ 构建标准返回结构
        result.setCode(apiResponse.getCode());
        result.setMsg(apiResponse.getMsg());
        result.setTraceId(apiResponse.getTraceId());
        result.setData(apiResponse.getData() != null ? apiResponse.getData() : new HashMap<>());

        // 如果有部分路径不存在，拼接提示信息
        if (!notExistPaths.isEmpty()) {
            result.setMsg(result.getMsg() + "（以下路径不存在，已跳过删除：" + notExistPaths + "）");
        }

        return result;
    }


}
